2.3 整合配置

1. package com.jastar.demo.dao.impl;  
2.   
3. import static org.springframework.data.mongodb.core.query.Criteria.where;  
4.   
5. import java.io.Serializable;  
6. import java.lang.reflect.Field;  
7. import java.lang.reflect.Method;  
8. import java.lang.reflect.Modifier;  
9. import java.util.ArrayList;  
10. import java.util.HashMap;  
11. import java.util.List;  
12. import java.util.Map;  
13.   
14. import org.springframework.beans.factory.annotation.Autowired;  
15. import org.springframework.data.annotation.Id;  
16. import org.springframework.data.domain.Sort;  
17. import org.springframework.data.domain.Sort.Direction;  
18. import org.springframework.data.domain.Sort.Order;  
19. import org.springframework.data.mongodb.core.MongoTemplate;  
20. import org.springframework.data.mongodb.core.query.Query;  
21. import org.springframework.data.mongodb.core.query.Update;  
22.   
23. import com.jastar.demo.dao.IBaseDao;  
24. import com.jastar.demo.util.EmptyUtil;  
25. import com.jastar.demo.util.PageModel;  
26.   
27. /** 
28.  * 基本操作接口MongoDB数据库实现类 
29.  * <p> 
30.  * ClassName: BaseDaoImpl 
31.  * </p> 
32.  * <p> 
33.  * Description:本实现类适用于MongoDB数据库，以下代码仅供参考，本人水平有限，可能会存在些许问题（如有更好方案可告知我，一定虚心学习）， 
34.  * 再次提醒，仅供参考！！ 
35.  * </p> 
36.  * <p> 
37.  * Copyright: (c)2017 Jastar·Wang,All rights reserved. 
38.  * </p> 
39.  *  
40.  * @author Jastar·Wang 
41.  * @date 2017年4月12日 
42.  */  
43. public abstract class BaseDaoImpl<T> implements IBaseDao<T> {  
44.   
45.     protected abstract Class<T> getEntityClass();  
46.   
47.     @Autowired  
48.     protected MongoTemplate mgt;  
49.   
50.     @Override  
51.     public void save(T entity) {  
52.         mgt.save(entity);  
53.     }  
54.   
55.     @Override  
56.     public void update(T entity) {  
57.   
58.         // 反向解析对象  
59.         Map<String, Object> map = null;  
60.         try {  
61.             map = parseEntity(entity);  
62.         } catch (Exception e) {  
63.             e.printStackTrace();  
64.         }  
65.   
66.         // ID字段  
67.         String idName = null;  
68.         Object idValue = null;  
69.   
70.         // 生成参数  
71.         Update update = new Update();  
72.         if (EmptyUtil.isNotEmpty(map)) {  
73.             for (String key : map.keySet()) {  
74.                 if (key.indexOf("{") != -1) {  
75.                     // 设置ID  
76.                     idName = key.substring(key.indexOf("{") + 1, key.indexOf("}"));  
77.                     idValue = map.get(key);  
78.                 } else {  
79.                     update.set(key, map.get(key));  
80.                 }  
81.             }  
82.         }  
83.         mgt.updateFirst(new Query().addCriteria(where(idName).is(idValue)), update, getEntityClass());  
84.     }  
85.   
86.     @Override  
87.     public void delete(Serializable... ids) {  
88.         if (EmptyUtil.isNotEmpty(ids)) {  
89.             for (Serializable id : ids) {  
90.                 mgt.remove(mgt.findById(id, getEntityClass()));  
91.             }  
92.         }  
93.   
94.     }  
95.   
96.     @Override  
97.     public T find(Serializable id) {  
98.         return mgt.findById(id, getEntityClass());  
99.     }  
100.   
101.     @Override  
102.     public List<T> findAll() {  
103.         return mgt.findAll(getEntityClass());  
104.     }  
105.   
106.     @Override  
107.     public List<T> findAll(String order) {  
108.         List<Order> orderList = parseOrder(order);  
109.         if (EmptyUtil.isEmpty(orderList)) {  
110.             return findAll();  
111.         }  
112.         return mgt.find(new Query().with(new Sort(orderList)), getEntityClass());  
113.     }  
114.   
115.     @Override  
116.     public List<T> findByProp(String propName, Object propValue) {  
117.         return findByProp(propName, propValue, null);  
118.     }  
119.   
120.     @Override  
121.     public List<T> findByProp(String propName, Object propValue, String order) {  
122.         Query query = new Query();  
123.         // 参数  
124.         query.addCriteria(where(propName).is(propValue));  
125.         // 排序  
126.         List<Order> orderList = parseOrder(order);  
127.         if (EmptyUtil.isNotEmpty(orderList)) {  
128.             query.with(new Sort(orderList));  
129.         }  
130.         return mgt.find(query, getEntityClass());  
131.     }  
132.   
133.     @Override  
134.     public List<T> findByProps(String[] propName, Object[] propValue) {  
135.         return findByProps(propName, propValue, null);  
136.     }  
137.   
138.     @Override  
139.     public List<T> findByProps(String[] propName, Object[] propValue, String order) {  
140.         Query query = createQuery(propName, propValue, order);  
141.         return mgt.find(query, getEntityClass());  
142.     }  
143.   
144.     @Override  
145.     public T uniqueByProp(String propName, Object propValue) {  
146.         return mgt.findOne(new Query(where(propName).is(propValue)), getEntityClass());  
147.     }  
148.   
149.     @Override  
150.     public T uniqueByProps(String[] propName, Object[] propValue) {  
151.         Query query = createQuery(propName, propValue, null);  
152.         return mgt.findOne(query, getEntityClass());  
153.     }  
154.   
155.     @Override  
156.     public PageModel<T> pageAll(int pageNo, int pageSize) {  
157.         return pageAll(pageNo, pageSize, null);  
158.     }  
159.   
160.     @Override  
161.     public PageModel<T> pageAll(int pageNo, int pageSize, String order) {  
162.         return pageByProp(pageNo, pageSize, null, null, order);  
163.     }  
164.   
165.     @Override  
166.     public PageModel<T> pageByProp(int pageNo, int pageSize, String param, Object value) {  
167.         return pageByProp(pageNo, pageSize, param, value, null);  
168.     }  
169.   
170.     @Override  
171.     public PageModel<T> pageByProp(int pageNo, int pageSize, String param, Object value, String order) {  
172.         String[] params = null;  
173.         Object[] values = null;  
174.         if (EmptyUtil.isNotEmpty(param)) {  
175.             params = new String[] { param };  
176.             values = new Object[] { value };  
177.         }  
178.         return pageByProps(pageNo, pageSize, params, values, order);  
179.     }  
180.   
181.     @Override  
182.     public PageModel<T> pageByProps(int pageNo, int pageSize, String[] params, Object[] values) {  
183.         return pageByProps(pageNo, pageSize, params, values, null);  
184.     }  
185.   
186.     @Override  
187.     public PageModel<T> pageByProps(int pageNo, int pageSize, String[] params, Object[] values, String order) {  
188.         // 创建分页模型对象  
189.         PageModel<T> page = new PageModel<>(pageNo, pageSize);  
190.   
191.         // 查询总记录数  
192.         int count = countByCondition(params, values);  
193.         page.setTotalCount(count);  
194.   
195.         // 查询数据列表  
196.         Query query = createQuery(params, values, order);  
197.   
198.         // 设置分页信息  
199.         query.skip(page.getFirstResult());  
200.         query.limit(page.getPageSize());  
201.   
202.         // 封装结果数据  
203.         page.setList(mgt.find(query, getEntityClass()));  
204.   
205.         return page;  
206.     }  
207.   
208.     @Override  
209.     public int countByCondition(String[] params, Object[] values) {  
210.         Query query = createQuery(params, values, null);  
211.         Long count = mgt.count(query, getEntityClass());  
212.         return count.intValue();  
213.     }  
214.   
215.     /** 
216.      * 创建带有where条件（只支持等值）和排序的Query对象 
217.      *  
218.      * @param params 
219.      *            参数数组 
220.      * @param values 
221.      *            参数值数组 
222.      * @param order 
223.      *            排序 
224.      * @return Query对象 
225.      */  
226.     protected Query createQuery(String[] params, Object[] values, String order) {  
227.         Query query = new Query();  
228.   
229.         // where 条件  
230.         if (EmptyUtil.isNotEmpty(params) && EmptyUtil.isNotEmpty(values)) {  
231.             for (int i = 0; i < params.length; i++) {  
232.                 query.addCriteria(where(params[i]).is(values[i]));  
233.             }  
234.         }  
235.   
236.         // 排序  
237.         List<Order> orderList = parseOrder(order);  
238.         if (EmptyUtil.isNotEmpty(orderList)) {  
239.             query.with(new Sort(orderList));  
240.         }  
241.   
242.         return query;  
243.     }  
244.   
245.     /** 
246.      * 解析Order字符串为所需参数 
247.      *  
248.      * @param order 
249.      *            排序参数，如[id]、[id asc]、[id asc,name desc] 
250.      * @return Order对象集合 
251.      */  
252.     protected List<Order> parseOrder(String order) {  
253.         List<Order> list = null;  
254.         if (EmptyUtil.isNotEmpty(order)) {  
255.             list = new ArrayList<Order>();  
256.             // 共有几组排序字段  
257.             String[] fields = order.split(",");  
258.             Order o = null;  
259.             String[] item = null;  
260.             for (int i = 0; i < fields.length; i++) {  
261.                 if (EmptyUtil.isEmpty(fields[i])) {  
262.                     continue;  
263.                 }  
264.                 item = fields[i].split(" ");  
265.                 if (item.length == 1) {  
266.                     o = new Order(Direction.ASC, item[0]);  
267.                 } else if (item.length == 2) {  
268.                     o = new Order("desc".equalsIgnoreCase(item[1]) ? Direction.DESC : Direction.ASC, item[0]);  
269.                 } else {  
270.                     throw new RuntimeException("排序字段参数解析出错");  
271.                 }  
272.                 list.add(o);  
273.             }  
274.         }  
275.         return list;  
276.     }  
277.   
278.     /** 
279.      * 将对象的字段及值反射解析为Map对象<br> 
280.      * 这里使用Java反射机制手动解析，并且可以识别注解为主键的字段，以达到根据id进行更新实体的目的<br> 
281.      * key：字段名称，value：字段对应的值 
282.      *  
283.      * @param t 
284.      *            要修改的对象 
285.      * @return Map对象，注意：id字段的key封装为“{id字段名称}”，以供后续识别 
286.      * @throws Exception 
287.      */  
288.     protected Map<String, Object> parseEntity(T t) throws Exception {  
289.         Map<String, Object> map = new HashMap<String, Object>();  
290.         /* 
291.          * 解析ID 
292.          */  
293.         String idName = "";  
294.         Field[] declaredFields = getEntityClass().getDeclaredFields();  
295.         for (Field field : declaredFields) {  
296.             if (field.isAnnotationPresent(Id.class)) {  
297.                 field.setAccessible(true);  
298.                 map.put("{" + field.getName() + "}", field.get(t));  
299.                 idName = field.getName();  
300.                 break;  
301.             }  
302.         }  
303.         /* 
304.          * 解析其他属性 
305.          */  
306.         Method[] methods = getEntityClass().getDeclaredMethods();  
307.         if (EmptyUtil.isNotEmpty(methods)) {  
308.             for (Method method : methods) {  
309.                 if (method.getName().startsWith("get") && method.getModifiers() == Modifier.PUBLIC) {  
310.                     String fieldName = parse2FieldName(method.getName());  
311.                     if (!fieldName.equals(idName)) {  
312.                         map.put(fieldName, method.invoke(t));  
313.                     }  
314.                 }  
315.             }  
316.         }  
317.   
318.         return map;  
319.     }  
320.   
321.     /** 
322.      * 将get方法名转换为对应的字段名称 
323.      *  
324.      * @param methodName 
325.      *            如：getName 
326.      * @return 如：name 
327.      */  
328.     private String parse2FieldName(String methodName) {  
329.         String name = methodName.replace("get", "");  
330.         name = name.substring(0, 1).toLowerCase() + name.substring(1);  
331.         return name;  
332.     }  
333.   
334. }  

1. package com.jastar.test;  
2.   
3. import java.sql.Timestamp;  
4. import java.util.List;  
5.   
6. import org.junit.Test;  
7. import org.junit.runner.RunWith;  
8. import org.springframework.beans.factory.annotation.Autowired;  
9. import org.springframework.test.context.ContextConfiguration;  
10. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;  
11.   
12. import com.jastar.demo.entity.UserInfo;  
13. import com.jastar.demo.service.UserService;  
14. import com.jastar.demo.util.PageModel;  
15.   
16. @RunWith(SpringJUnit4ClassRunner.class)  
17. @ContextConfiguration(locations = "classpath:spring-mgo.xml")  
18. public class TestUserService {  
19.   
20.     @Autowired  
21.     private UserService service;  
22.   
23.     @Test  
24.     public void save() {  
25.         UserInfo user = new UserInfo();  
26.         user.setName("张三");  
27.         user.setAge(25);  
28.         user.setBirth(Timestamp.valueOf("2017-4-12 16:52:00"));  
29.         service.save(user);  
30.         System.out.println("已生成ID:" + user.getId());  
31.     }  
32.   
33.     @Test  
34.     public void find() {  
35.         UserInfo user = service.find("58edf1b26f033406394a8a61");  
36.         System.out.println(user.getName());  
37.     }  
38.   
39.     @Test  
40.     public void update() {  
41.         UserInfo user = service.find("58edf1b26f033406394a8a61");  
42.         user.setAge(18);  
43.         service.update(user);  
44.     }  
45.   
46.     @Test  
47.     public void delete() {  
48.         service.delete("58edef886f03c7b0fdba51b9");  
49.     }  
50.   
51.     @Test  
52.     public void findAll() {  
53.         List<UserInfo> list = service.findAll("age desc");  
54.         for (UserInfo u : list) {  
55.             System.out.println(u.getName());  
56.         }  
57.     }  
58.   
59.     @Test  
60.     public void findByProp() {  
61.         List<UserInfo> list = service.findByProp("name", "张三");  
62.         for (UserInfo u : list) {  
63.             System.out.println(u.getName());  
64.         }  
65.     }  
66.   
67.     @Test  
68.     public void findByProps() {  
69.         List<UserInfo> list = service.findByProps(new String[] { "name", "age" }, new Object[] { "张三", 18 });  
70.         for (UserInfo u : list) {  
71.             System.out.println(u.getName());  
72.         }  
73.     }  
74.   
75.     @Test  
76.     public void pageAll() {  
77.         PageModel<UserInfo> page = service.pageAll(1, 10);  
78.         System.out.println("总记录：" + page.getTotalCount() + "，总页数：" + page.getTotalPage());  
79.         for (UserInfo u : page.getList()) {  
80.             System.out.println(u.getName());  
81.         }  
82.     }  
83.   
84.     @Test  
85.     public void pageByProp() {  
86.         PageModel<UserInfo> page = service.pageByProp(1, 10, "name", "张三");  
87.         System.out.println("总记录：" + page.getTotalCount() + "，总页数：" + page.getTotalPage());  
88.         for (UserInfo u : page.getList()) {  
89.             System.out.println(u.getName());  
90.         }  
91.     }  
92.   
93. }